// import Cookies from 'js-cookie'
import { authApi } from '@/api/api'
import {
  getUrlParams,
  routerPush,
  clearLocalStorage,
  getProjectContext,
  getStorageKey,
  isRealEmpty
} from '@/utils/common'
import { context } from '@/utils/until'


/**
 * Note 该文件考虑为三端通用登录，修改该文件需要考虑通用性
 *
 * 1、中台没有微信登陆
 * 2、公有云使用cookies，中台使用localStorage
 *
 * vm：Vue实例
 * authCode
 * callbackUrl：登录中心回调地址
 * context：API上下文地址
 * accountType  登录平台类型【开发平台：ADMIN，pc运行平台：USER，移动端运行平台：MOBILE_USER，运营平台：OPERATION_ADMIN】
 *
*/
const _accountType = 'ADMIN'
const _userCacheKey = getStorageKey('userData')
const _redirectUrlKey = getStorageKey('consoleRedirectUrl')
const _redirectDefaulCallback = (vm) => {
  routerPush({
    vm,
    mode: 'mpa',
    pageName: 'apply',
    path: 'list'
  })
}

const debug = (arg) => {
  const isDebug = true
  if (isDebug) {
    console.log(arg)
  }
}

class LoginController {
  constructor({ vm, callbackUrl, authCode }) {
    this.context = context
    this.vm = vm || null
    this.accountType = _accountType || null
    this.callbackUrl = callbackUrl || null
    this.authCode = authCode || null
    debug('***[登陆】构造LoginController***')
    if (!this.vm) {
      debug('***[登陆】vue实例为空***')
    }
  }
}

class CloudLoginController extends LoginController {
  constructor(model) {
    super(model)
    debug(`***[登陆】当前为${_accountType}认证模式***`)
  }

  async goErrorPage(errorCode) {
    // 清除本地指定缓存
    clearLocalStorage()
  }

  // 验证token有效性
  async verifyStatus() {
    const res = (await authApi.validateAuth({ skipToken: true })).data
    console.log(2233, res)
    try {
      if (res.code === 0) {
        // TODO_login VIP 暂时隐藏
        // this.addressBookCheck()
        return true
      }
    } catch (error) {
      console.error(error)
    }
    return false
  }

  // 登录回调操作
  async loginCallBack() {
    const data = {
      accountType: this.accountType,
      authCode: this.authCode,
      domain: window.location.hostname,
      // 此处使用api接口的上下文地址
      path: `${this.context}`
    }
    const res = (await authApi.loginCallBack(data)).data
    if (res.code === 0) {
      return 'authCodeLogin'
    } else {
      this.goErrorPage(res.code)
    }
  }

  // 获取登录中心地址
  async getAuthUrl() {
    const data = {
      accountType: this.accountType,
      // corpId: this.corpId,
      callbackUrl: encodeURIComponent(this.callbackUrl)
    }
    const res = (await authApi.getAuthUrl(data)).data
    if (res.code === 0) {
      window.location.href = res.data
    }
  }

  // 登录初始化
  async login(callback) {
    // 中台登录跳转回来会携带authCode
    if (this.authCode) {
      // 检测原先有没有用户登录
      const loginStatus = await this.verifyStatus()
      debugger
      if (loginStatus) {
        this.authCode = null
        await callback()
      } else {
        const res = await this.loginCallBack()
        if (res === 'authCodeLogin') {
          await callback()
        }
      }
    } else {
      
      // 普通访问
      const loginStatus = await this.verifyStatus()
      if (loginStatus) {
        await callback()
      } else {
        await this.getAuthUrl()
      }
    }
  }

  // 获取用户信息
  async getUserData() {
    const res = (await authApi.getSessionData()).data
    try {
      if (res.code === 0) {
        setLocalUserData(res.data)
      }
    } catch (error) {
      console.error(error)
    }
    return false
  }

  // TODO 待废弃
  /**
   * [cleanLoginCache 针对以往公有云、基座模式下同一域名不同登录模式记录的缓存数据，进行统一的清除]
   */
  cleanLoginCache() {
    localStorage.removeItem('webTokenData')
    localStorage.removeItem('tokenData')
    localStorage.removeItem('TokenData')
  }

  async loginOut(type = {}) {
    // 调用如下 authUtils.getInstance({ vm: this }).loginOut()
    const postData = {
      accountType: this.accountType,
      domain: window.location.hostname,
      path: `${this.context}`
    }
    const logoutData = (await authApi.authLogout(postData)).data
    if (logoutData.code === 0) {
      if (type.msg !== 'toLogin') {
        this.vm.$message.success('退出成功！')
      }
      // 清除本地指定缓存
      clearLocalStorage()
      // 清除本地所有缓存数据
      localStorage.clear()
      // 返回登录页
      setTimeout(() => {
        routerPush({
          vm: this.vm,
          mode: 'mpa',
          path: 'login'
        })
      }, 300)
    } else {
      // 登录失败，提示异常
      this.vm.$message.error(logoutData.msg)
    }
  }
}
/**
 * 获取当前已登录本地用户信息
 * @param {*} noData 查询不到或报错时返回的值
 */
function getLocalUserData(noData = {}) {
  try {
    // TODO 公有云需要等2.0.2发布正式环境后，可将_oldUserCacheKey去掉
    // 由于release-2.0.2 修改获取用户信息的key，发生灰度和正式的缓存数据获取问题。
    // 第一次登录login走了正式，没有写入新用户key，导致登录后进入apply灰度，拿不到对应用户信息，
    // 在src/view/index.vue beforeRouteEnter 获取不到corpId，直接重定向回login.vue
    const _oldUserCacheKey = 'qiqiao2-userData'
    const oldUserData = localStorage.getItem(_oldUserCacheKey)
    const newUserData = localStorage.getItem(_userCacheKey)
    if (newUserData) {
      return JSON.parse(newUserData)
    }
    if (oldUserData) {
      localStorage.setItem(_userCacheKey, oldUserData)
      return JSON.parse(oldUserData)
    }
    return noData
  } catch (err) {
    return noData
  }
}
/**
 * 设置用户信息到缓存
 */
export function setLocalUserData(userData = null) {
  // 判断传入的值是否是对象,且不为空
  if (!isRealEmpty(userData)) {
    localStorage.setItem(_userCacheKey, JSON.stringify(userData))
  }
}
function getAuthCodeAnCorpId(vm) {
  const { fullPath, path } = vm.$route
  const { redirect, authCode } = vm.$route.query
  let newRedirect = redirect
  let realAuthCode = authCode
  // 由于单点登录重定向回来的地址并不是指向login, authCode是拼在重定向的地址上,为了正常走loginCallBack的登录逻辑, 所以需要从缓存取一下
  const authCodeKey = getStorageKey('authCode')
  if (sessionStorage.getItem(authCodeKey)) {
    realAuthCode = sessionStorage.getItem(authCodeKey)
    sessionStorage.removeItem(authCodeKey)
  }

  const tempPath = fullPath.split(path)[1].slice(1)
  if (tempPath.indexOf('authCode=') !== -1) {
    realAuthCode = tempPath.split('authCode=')[1]
  }
  if (tempPath.indexOf('redirect=') !== -1) {
    newRedirect = tempPath.split('redirect=')[1]
    if (newRedirect.indexOf('&authCode=')) {
      realAuthCode = newRedirect.split('&authCode=')[0]
    }
  }
  //  获取corpId信息 & appId信息
  const queryList = window.location.search

  let paramsMap = getUrlParams(queryList)
  const appId = paramsMap.appId || null
  let corpId = paramsMap.corp_id || ''
  if (corpId && newRedirect) {
    // 若无，检查一下重定向url上有无
    paramsMap = getUrlParams(newRedirect)
    corpId = paramsMap.corp_id || ''
  }
  // 在登录回调过程中,如果取不到authCode,会不断重定向
  realAuthCode = paramsMap.authCode || realAuthCode

  if (realAuthCode && realAuthCode.indexOf('#/') !== -1) {
    realAuthCode = realAuthCode.replace('#/', '')
  }
  // alert('gAuthCode' + realAuthCode)
  return { authCode: realAuthCode, redirect: newRedirect, corpId, appId }
}

function goRediect({ vm }) {

  const redirectUrl = sessionStorage.getItem(_redirectUrlKey)
  // 查询缓存中是否存在重定向地址
  let realUrl = null
  if (redirectUrl) {
    realUrl = redirectUrl
    sessionStorage.removeItem(_redirectUrlKey)
  }

  if (realUrl && realUrl.indexOf('login') !== -1) {
    realUrl = null
  }
  if (realUrl) {
    window.location.href = decodeURIComponent(realUrl)
  } else {
    _redirectDefaulCallback(vm)
  }
}
/**
 * changeUserType 身份转换
 * @param {*} callbackUrl 回调地址
 * @returns res
 */
async function changeUserType(callbackUrl) {
  const currentId = await getCurrentId()
  const res = (await authApi.getAuthUrlByAccount({
    currentId,
    // 中台为解决&符号被转成;amp,所以需要转码两次
    callbackUrl: encodeURIComponent(encodeURIComponent(callbackUrl)),
    changeLoginType: 'USER',
    loginType: 'ADMIN'
  })).data
  return res
}
/*
* getCurrentId 获取当前用户的currentId信息
*/
async function getCurrentId() {
  // 从缓存中获取信息
  const userData = getLocalUserData()
  // 错误信息
  let err = null
  if (userData.currentId) {
    return userData.currentId
  } else {
    try {
      const res = (await authApi.getSessionData()).data
      // 新用户信息
      let newData = {}
      if (res.code === 0 && res.data) {
        newData = res.data
        // 将新用户信息进行添加到本地
        setLocalUserData(newData)
        if (newData.currentId) {
          return newData.currentId
        } else {
          err = { errMsg: 'getSessionData接口返回信息中没有currentId' }
        }
      } else {
        err = { errMsg: JSON.stringify(res) }
      }

      throw err
    } catch (error) {
      console.error(error)
      return ''
    }
  }
}

const authUtils = {
  setInstance: ({ vm }) => {
    if (!vm) {
      console.error('**[登陆】必传参数：vue实例为空***')
      return
    }
    if (!window.loginInstance) {
      const { authCode } = authUtils.getAuthCodeAnCorpId(vm)
      const context = getProjectContext() || '/'
      const loginData = {
        vm,
        callbackUrl: `${window.location.origin}${context}#/login`,
        authCode
      }
      window.loginInstance = new CloudLoginController(loginData)
    }
  },
  getInstance: (data) => {
    if (!window.loginInstance) {
      authUtils.setInstance(data)
    }
    return window.loginInstance
  },
  getAuthCodeAnCorpId,
  goRediect,
  changeUserType,
  getCurrentId,
  getLocalUserData,
  setLocalUserData
}

export default authUtils
